import java.util.*;


public class day4 {
    /**
     * DP16 合唱队形
     * https://www.nowcoder.com/practice/0045cd3e39634a66ada63c2adeb49234?tpId=230&tqId=39759&ru=/exam/oj
     */
    public static void main3(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n + 1];
        for(int i = 1;i <= n;i++) {
            arr[i] = in.nextInt();
        }
        // 计算最长的升序
        // 分别从左到右，从右到左进行统计
        int[] f = new int[n + 1]; // 表示：从0~i位置的数据，最长的升序子序列
        int[] g = new int[n + 1]; // 表示：从n-1~i位置的数据，最长的升序子序列


        // 从左到右
        for(int i = 1;i <= n;i++) {
            f[i] = 1; // 本身也是一个子序列
            for(int j = 1;j < i;j++) {
                if(arr[i] > arr[j]) {
                    // 构成升序，进行统计最长的
                    f[i] = Math.max(f[i],f[j] + 1);
                }
            }
        }

        // 从右到左
        for(int i = n;i >= 1;i--) {
            g[i] = 1;
            for(int j = n;j > i;j--) {
                if(arr[i] > arr[j]) {
                    g[i] = Math.max(g[i],g[j] + 1);
                }
            }
        }

        int len = 0;
        for(int i = 1;i <= n;i++) {
            len = Math.max(len,f[i] + g[i] - 1);
        }

        System.out.println(n - len);
    }




    /**
     * NC316 体育课测验(二)
     * https://www.nowcoder.com/practice/64a4c026b2aa4411984f560deec36323?tpId=196&tqId=40272&ru=/exam/oj
     */
    public ArrayList<Integer> findOrder (int numProject, ArrayList<ArrayList<Integer>> groups) {
        // 拓扑排序
        // 建立一个存储边的结构
        // 比如：b -> a ; b -> c
        ArrayList<ArrayList<Integer>> edges = new ArrayList<>();
        for(int i = 0;i < numProject;i++) {
            edges.add(new ArrayList<>());
        }
        //记录入度的值，每一个数
        int[] in = new int[numProject];

        // 建图
        for(int i = 0;i < groups.size();i++) {
            int a = groups.get(i).get(0);
            int b = groups.get(i).get(1);
            // b -> a
            // a 就存在一个入度
            in[a]++;
            // 放到边的结构中
            edges.get(b).add(a);
        }

        Queue<Integer> queue = new LinkedList<>();
        // 将入度为0的值放入队列中
        for(int i = 0;i < numProject;i++) {
            if(in[i] == 0) {
                queue.add(i);
            }
        }

        ArrayList<Integer> ret = new ArrayList<>();
        // 拓扑排序
        while(!queue.isEmpty()) {
            int b = queue.poll();
            ret.add(b);
            for(int a : edges.get(b)) {
                // b -> a
                if(--in[a] == 0) {
                    queue.add(a);
                }
            }
        }
        if(ret.size() == numProject) {
            return ret;
        }else {
            return new ArrayList<>();
        }
    }



    /**
     * 游游的字母串
     * https://ac.nowcoder.com/acm/problem/255195
     */
    public static void main(String[] args) {
        //暴力枚举，计算转换成每一个字符的最小值
        Scanner in = new Scanner(System.in);
        char[] s = in.next().toCharArray();
        int n = s.length;
        int ret = (int)1e9;
        for(char ch = 'a';ch <= 'z';ch++) {
            // 将其字符串转换成每一个单词的最小值
            int sum = 0;
            for(int i = 0;i < n;i++) {
                // 因为是一个环状，所以可以从头或者从尾转换
                sum += Math.min(Math.abs(s[i] - ch),26 - Math.abs(ch - s[i]));
            }
            // 每次转换成一个之后，进行记录
            ret = Math.min(ret,sum);
        }
        System.out.println(ret);
    }
}
